home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / tex / tex31 / texsrc.lzh / TEXSRC.LZH / tex8.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-11-28  |  24.4 KB  |  1,013 lines
  1. #define EXTERN extern
  2. #include "texd.h"
  3.  
  4. void zshipout ( p ) 
  5. halfword p ; 
  6. {/* 30 */ shipout_regmem 
  7.   integer pageloc  ; 
  8.   schar j, k  ; 
  9.   poolpointer s  ; 
  10.   schar oldsetting  ; 
  11.   if ( eqtb [ 6197 ] .cint > 0 ) 
  12.   {
  13.     printnl ( 335 ) ; 
  14.     println () ; 
  15.     print ( 822 ) ; 
  16.   } 
  17.   if ( termoffset > maxprintline - 9 ) 
  18.   println () ; 
  19.   else if ( ( termoffset > 0 ) || ( fileoffset > 0 ) ) 
  20.   printchar ( 32 ) ; 
  21.   printchar ( 91 ) ; 
  22.   j = 9 ; 
  23.   while ( ( eqtb [ 6218 + j ] .cint == 0 ) && ( j > 0 ) ) decr ( j ) ; 
  24.   {register integer for_end; k = 0 ; for_end = j ; if ( k <= for_end) do 
  25.     {
  26.       printint ( eqtb [ 6218 + k ] .cint ) ; 
  27.       if ( k < j ) 
  28.       printchar ( 46 ) ; 
  29.     } 
  30.   while ( k++ < for_end ) ; } 
  31.   flush ( stdout ) ; 
  32.   if ( eqtb [ 6197 ] .cint > 0 ) 
  33.   {
  34.     printchar ( 93 ) ; 
  35.     begindiagnostic () ; 
  36.     showbox ( p ) ; 
  37.     enddiagnostic ( true ) ; 
  38.   } 
  39.   if ( ( mem [ p + 3 ] .cint > 1073741823L ) || ( mem [ p + 2 ] .cint > 
  40.   1073741823L ) || ( mem [ p + 3 ] .cint + mem [ p + 2 ] .cint + eqtb [ 6749 ] 
  41.   .cint > 1073741823L ) || ( mem [ p + 1 ] .cint + eqtb [ 6748 ] .cint > 
  42.   1073741823L ) ) 
  43.   {
  44.     {
  45.       if ( interaction == 3 ) 
  46.       wakeupterminal () ; 
  47.       printnl ( 262 ) ; 
  48.       print ( 826 ) ; 
  49.     } 
  50.     {
  51.       helpptr = 2 ; 
  52.       helpline [ 1 ] = 827 ; 
  53.       helpline [ 0 ] = 828 ; 
  54.     } 
  55.     error () ; 
  56.     if ( eqtb [ 6197 ] .cint <= 0 ) 
  57.     {
  58.       begindiagnostic () ; 
  59.       printnl ( 829 ) ; 
  60.       showbox ( p ) ; 
  61.       enddiagnostic ( true ) ; 
  62.     } 
  63.     goto lab30 ; 
  64.   } 
  65.   if ( mem [ p + 3 ] .cint + mem [ p + 2 ] .cint + eqtb [ 6749 ] .cint > maxv 
  66.   ) 
  67.   maxv = mem [ p + 3 ] .cint + mem [ p + 2 ] .cint + eqtb [ 6749 ] .cint ; 
  68.   if ( mem [ p + 1 ] .cint + eqtb [ 6748 ] .cint > maxh ) 
  69.   maxh = mem [ p + 1 ] .cint + eqtb [ 6748 ] .cint ; 
  70.   dvih = 0 ; 
  71.   dviv = 0 ; 
  72.   curh = eqtb [ 6748 ] .cint ; 
  73.   dvif = 0 ; 
  74.   if ( outputfilename == 0 ) 
  75.   {
  76.     if ( jobname == 0 ) 
  77.     openlogfile () ; 
  78.     packjobname ( 787 ) ; 
  79.     while ( ! bopenout ( dvifile ) ) promptfilename ( 788 , 787 ) ; 
  80.     outputfilename = bmakenamestring ( dvifile ) ; 
  81.   } 
  82.   if ( totalpages == 0 ) 
  83.   {
  84.     {
  85.       dvibuf [ dviptr ] = 247 ; 
  86.       incr ( dviptr ) ; 
  87.       if ( dviptr == dvilimit ) 
  88.       dviswap () ; 
  89.     } 
  90.     {
  91.       dvibuf [ dviptr ] = 2 ; 
  92.       incr ( dviptr ) ; 
  93.       if ( dviptr == dvilimit ) 
  94.       dviswap () ; 
  95.     } 
  96.     dvifour ( 25400000L ) ; 
  97.     dvifour ( 473628672L ) ; 
  98.     preparemag () ; 
  99.     dvifour ( eqtb [ 6180 ] .cint ) ; 
  100.     oldsetting = selector ; 
  101.     selector = 21 ; 
  102.     print ( 820 ) ; 
  103.     printint ( eqtb [ 6186 ] .cint ) ; 
  104.     printchar ( 46 ) ; 
  105.     printtwo ( eqtb [ 6185 ] .cint ) ; 
  106.     printchar ( 46 ) ; 
  107.     printtwo ( eqtb [ 6184 ] .cint ) ; 
  108.     printchar ( 58 ) ; 
  109.     printtwo ( eqtb [ 6183 ] .cint / 60 ) ; 
  110.     printtwo ( eqtb [ 6183 ] .cint % 60 ) ; 
  111.     selector = oldsetting ; 
  112.     {
  113.       dvibuf [ dviptr ] = ( poolptr - strstart [ strptr ] ) ; 
  114.       incr ( dviptr ) ; 
  115.       if ( dviptr == dvilimit ) 
  116.       dviswap () ; 
  117.     } 
  118.     {register integer for_end; s = strstart [ strptr ] ; for_end = poolptr - 
  119.     1 ; if ( s <= for_end) do 
  120.       {
  121.     dvibuf [ dviptr ] = strpool [ s ] ; 
  122.     incr ( dviptr ) ; 
  123.     if ( dviptr == dvilimit ) 
  124.     dviswap () ; 
  125.       } 
  126.     while ( s++ < for_end ) ; } 
  127.     poolptr = strstart [ strptr ] ; 
  128.   } 
  129.   pageloc = dvioffset + dviptr ; 
  130.   {
  131.     dvibuf [ dviptr ] = 139 ; 
  132.     incr ( dviptr ) ; 
  133.     if ( dviptr == dvilimit ) 
  134.     dviswap () ; 
  135.   } 
  136.   {register integer for_end; k = 0 ; for_end = 9 ; if ( k <= for_end) do 
  137.     dvifour ( eqtb [ 6218 + k ] .cint ) ; 
  138.   while ( k++ < for_end ) ; } 
  139.   dvifour ( lastbop ) ; 
  140.   lastbop = pageloc ; 
  141.   curv = mem [ p + 3 ] .cint + eqtb [ 6749 ] .cint ; 
  142.   tempptr = p ; 
  143.   if ( mem [ p ] .hh.b0 == 1 ) 
  144.   vlistout () ; 
  145.   else hlistout () ; 
  146.   {
  147.     dvibuf [ dviptr ] = 140 ; 
  148.     incr ( dviptr ) ; 
  149.     if ( dviptr == dvilimit ) 
  150.     dviswap () ; 
  151.   } 
  152.   incr ( totalpages ) ; 
  153.   curs = -1 ; 
  154.   lab30: ; 
  155.   if ( eqtb [ 6197 ] .cint <= 0 ) 
  156.   printchar ( 93 ) ; 
  157.   deadcycles = 0 ; 
  158.   flush ( stdout ) ; 
  159.     ;
  160. #ifdef STAT
  161.   if ( eqtb [ 6194 ] .cint > 1 ) 
  162.   {
  163.     printnl ( 823 ) ; 
  164.     printint ( varused ) ; 
  165.     printchar ( 38 ) ; 
  166.     printint ( dynused ) ; 
  167.     printchar ( 59 ) ; 
  168.   } 
  169. #endif /* STAT */
  170.   flushnodelist ( p ) ; 
  171.     ;
  172. #ifdef STAT
  173.   if ( eqtb [ 6194 ] .cint > 1 ) 
  174.   {
  175.     print ( 824 ) ; 
  176.     printint ( varused ) ; 
  177.     printchar ( 38 ) ; 
  178.     printint ( dynused ) ; 
  179.     print ( 825 ) ; 
  180.     printint ( himemmin - lomemmax - 1 ) ; 
  181.     println () ; 
  182.   } 
  183. #endif /* STAT */
  184. } 
  185. void zscanspec ( c , threecodes ) 
  186. groupcode c ; 
  187. boolean threecodes ; 
  188. {/* 40 */ scanspec_regmem 
  189.   integer s  ; 
  190.   schar speccode  ; 
  191.   if ( threecodes ) 
  192.   s = savestack [ saveptr + 0 ] .cint ; 
  193.   if ( scankeyword ( 835 ) ) 
  194.   speccode = 0 ; 
  195.   else if ( scankeyword ( 836 ) ) 
  196.   speccode = 1 ; 
  197.   else {
  198.       
  199.     speccode = 1 ; 
  200.     curval = 0 ; 
  201.     goto lab40 ; 
  202.   } 
  203.   scandimen ( false , false , false ) ; 
  204.   lab40: if ( threecodes ) 
  205.   {
  206.     savestack [ saveptr + 0 ] .cint = s ; 
  207.     incr ( saveptr ) ; 
  208.   } 
  209.   savestack [ saveptr + 0 ] .cint = speccode ; 
  210.   savestack [ saveptr + 1 ] .cint = curval ; 
  211.   saveptr = saveptr + 2 ; 
  212.   newsavelevel ( c ) ; 
  213.   scanleftbrace () ; 
  214. } 
  215. halfword zhpack ( p , w , m ) 
  216. halfword p ; 
  217. scaled w ; 
  218. smallnumber m ; 
  219. {/* 21 50 10 */ register halfword Result; hpack_regmem 
  220.   halfword r  ; 
  221.   halfword q  ; 
  222.   scaled h, d, x  ; 
  223.   scaled s  ; 
  224.   halfword g  ; 
  225.   glueord o  ; 
  226.   internalfontnumber f  ; 
  227.   fourquarters i  ; 
  228.   eightbits hd  ; 
  229.   lastbadness = 0 ; 
  230.   r = getnode ( 7 ) ; 
  231.   mem [ r ] .hh.b0 = 0 ; 
  232.   mem [ r ] .hh.b1 = 0 ; 
  233.   mem [ r + 4 ] .cint = 0 ; 
  234.   q = r + 5 ; 
  235.   mem [ q ] .hh .v.RH = p ; 
  236.   h = 0 ; 
  237.   d = 0 ; 
  238.   x = 0 ; 
  239.   totalstretch [ 0 ] = 0 ; 
  240.   totalshrink [ 0 ] = 0 ; 
  241.   totalstretch [ 1 ] = 0 ; 
  242.   totalshrink [ 1 ] = 0 ; 
  243.   totalstretch [ 2 ] = 0 ; 
  244.   totalshrink [ 2 ] = 0 ; 
  245.   totalstretch [ 3 ] = 0 ; 
  246.   totalshrink [ 3 ] = 0 ; 
  247.   while ( p != 0 ) {
  248.       
  249.     lab21: while ( ( p >= himemmin ) ) {
  250.     
  251.       f = mem [ p ] .hh.b0 ; 
  252.       i = fontinfo [ charbase [ f ] + mem [ p ] .hh.b1 ] .qqqq ; 
  253.       hd = i .b1 ; 
  254.       x = x + fontinfo [ widthbase [ f ] + i .b0 ] .cint ; 
  255.       s = fontinfo [ heightbase [ f ] + ( hd ) / 16 ] .cint ; 
  256.       if ( s > h ) 
  257.       h = s ; 
  258.       s = fontinfo [ depthbase [ f ] + ( hd ) % 16 ] .cint ; 
  259.       if ( s > d ) 
  260.       d = s ; 
  261.       p = mem [ p ] .hh .v.RH ; 
  262.     } 
  263.     if ( p != 0 ) 
  264.     {
  265.       switch ( mem [ p ] .hh.b0 ) 
  266.       {case 0 : 
  267.       case 1 : 
  268.       case 2 : 
  269.       case 13 : 
  270.     {
  271.       x = x + mem [ p + 1 ] .cint ; 
  272.       if ( mem [ p ] .hh.b0 >= 2 ) 
  273.       s = 0 ; 
  274.       else s = mem [ p + 4 ] .cint ; 
  275.       if ( mem [ p + 3 ] .cint - s > h ) 
  276.       h = mem [ p + 3 ] .cint - s ; 
  277.       if ( mem [ p + 2 ] .cint + s > d ) 
  278.       d = mem [ p + 2 ] .cint + s ; 
  279.     } 
  280.     break ; 
  281.       case 3 : 
  282.       case 4 : 
  283.       case 5 : 
  284.     if ( adjusttail != 0 ) 
  285.     {
  286.       while ( mem [ q ] .hh .v.RH != p ) q = mem [ q ] .hh .v.RH ; 
  287.       if ( mem [ p ] .hh.b0 == 5 ) 
  288.       {
  289.         mem [ adjusttail ] .hh .v.RH = mem [ p + 1 ] .cint ; 
  290.         while ( mem [ adjusttail ] .hh .v.RH != 0 ) adjusttail = mem [ 
  291.         adjusttail ] .hh .v.RH ; 
  292.         p = mem [ p ] .hh .v.RH ; 
  293.         freenode ( mem [ q ] .hh .v.RH , 2 ) ; 
  294.       } 
  295.       else {
  296.           
  297.         mem [ adjusttail ] .hh .v.RH = p ; 
  298.         adjusttail = p ; 
  299.         p = mem [ p ] .hh .v.RH ; 
  300.       } 
  301.       mem [ q ] .hh .v.RH = p ; 
  302.       p = q ; 
  303.     } 
  304.     break ; 
  305.       case 8 : 
  306.     ; 
  307.     break ; 
  308.       case 10 : 
  309.     {
  310.       g = mem [ p + 1 ] .hh .v.LH ; 
  311.       x = x + mem [ g + 1 ] .cint ; 
  312.       o = mem [ g ] .hh.b0 ; 
  313.       totalstretch [ o ] = totalstretch [ o ] + mem [ g + 2 ] .cint ; 
  314.       o = mem [ g ] .hh.b1 ; 
  315.       totalshrink [ o ] = totalshrink [ o ] + mem [ g + 3 ] .cint ; 
  316.       if ( mem [ p ] .hh.b1 >= 100 ) 
  317.       {
  318.         g = mem [ p + 1 ] .hh .v.RH ; 
  319.         if ( mem [ g + 3 ] .cint > h ) 
  320.         h = mem [ g + 3 ] .cint ; 
  321.         if ( mem [ g + 2 ] .cint > d ) 
  322.         d = mem [ g + 2 ] .cint ; 
  323.       } 
  324.     } 
  325.     break ; 
  326.       case 11 : 
  327.       case 9 : 
  328.     x = x + mem [ p + 1 ] .cint ; 
  329.     break ; 
  330.       case 6 : 
  331.     {
  332.       mem [ memtop - 12 ] = mem [ p + 1 ] ; 
  333.       mem [ memtop - 12 ] .hh .v.RH = mem [ p ] .hh .v.RH ; 
  334.       p = memtop - 12 ; 
  335.       goto lab21 ; 
  336.     } 
  337.     break ; 
  338.     default: 
  339.     ; 
  340.     break ; 
  341.       } 
  342.       p = mem [ p ] .hh .v.RH ; 
  343.     } 
  344.   } 
  345.   if ( adjusttail != 0 ) 
  346.   mem [ adjusttail ] .hh .v.RH = 0 ; 
  347.   mem [ r + 3 ] .cint = h ; 
  348.   mem [ r + 2 ] .cint = d ; 
  349.   if ( m == 1 ) 
  350.   w = x + w ; 
  351.   mem [ r + 1 ] .cint = w ; 
  352.   x = w - x ; 
  353.   if ( x == 0 ) 
  354.   {
  355.     mem [ r + 5 ] .hh.b0 = 0 ; 
  356.     mem [ r + 5 ] .hh.b1 = 0 ; 
  357.     mem [ r + 6 ] .gr = 0.0 ; 
  358.     goto lab10 ; 
  359.   } 
  360.   else if ( x > 0 ) 
  361.   {
  362.     if ( totalstretch [ 3 ] != 0 ) 
  363.     o = 3 ; 
  364.     else if ( totalstretch [ 2 ] != 0 ) 
  365.     o = 2 ; 
  366.     else if ( totalstretch [ 1 ] != 0 ) 
  367.     o = 1 ; 
  368.     else o = 0 ; 
  369.     mem [ r + 5 ] .hh.b1 = o ; 
  370.     mem [ r + 5 ] .hh.b0 = 1 ; 
  371.     if ( totalstretch [ o ] != 0 ) 
  372.     mem [ r + 6 ] .gr = x / ((double) totalstretch [ o ] ) ; 
  373.     else {
  374.     
  375.       mem [ r + 5 ] .hh.b0 = 0 ; 
  376.       mem [ r + 6 ] .gr = 0.0 ; 
  377.     } 
  378.     if ( o == 0 ) 
  379.     if ( mem [ r + 5 ] .hh .v.RH != 0 ) 
  380.     {
  381.       lastbadness = badness ( x , totalstretch [ 0 ] ) ; 
  382.       if ( lastbadness > eqtb [ 6189 ] .cint ) 
  383.       {
  384.     println () ; 
  385.     if ( lastbadness > 100 ) 
  386.     printnl ( 837 ) ; 
  387.     else printnl ( 838 ) ; 
  388.     print ( 839 ) ; 
  389.     printint ( lastbadness ) ; 
  390.     goto lab50 ; 
  391.       } 
  392.     } 
  393.     goto lab10 ; 
  394.   } 
  395.   else {
  396.       
  397.     if ( totalshrink [ 3 ] != 0 ) 
  398.     o = 3 ; 
  399.     else if ( totalshrink [ 2 ] != 0 ) 
  400.     o = 2 ; 
  401.     else if ( totalshrink [ 1 ] != 0 ) 
  402.     o = 1 ; 
  403.     else o = 0 ; 
  404.     mem [ r + 5 ] .hh.b1 = o ; 
  405.     mem [ r + 5 ] .hh.b0 = 2 ; 
  406.     if ( totalshrink [ o ] != 0 ) 
  407.     mem [ r + 6 ] .gr = ( - (integer) x ) / ((double) totalshrink [ o ] ) ; 
  408.     else {
  409.     
  410.       mem [ r + 5 ] .hh.b0 = 0 ; 
  411.       mem [ r + 6 ] .gr = 0.0 ; 
  412.     } 
  413.     if ( ( totalshrink [ o ] < - (integer) x ) && ( o == 0 ) && ( mem [ r + 5 
  414.     ] .hh .v.RH != 0 ) ) 
  415.     {
  416.       lastbadness = 1000000L ; 
  417.       mem [ r + 6 ] .gr = 1.0 ; 
  418.       if ( ( - (integer) x - totalshrink [ 0 ] > eqtb [ 6738 ] .cint ) || ( 
  419.       eqtb [ 6189 ] .cint < 100 ) ) 
  420.       {
  421.     if ( ( eqtb [ 6746 ] .cint > 0 ) && ( - (integer) x - totalshrink [ 0 
  422.     ] > eqtb [ 6738 ] .cint ) ) 
  423.     {
  424.       while ( mem [ q ] .hh .v.RH != 0 ) q = mem [ q ] .hh .v.RH ; 
  425.       mem [ q ] .hh .v.RH = newrule () ; 
  426.       mem [ mem [ q ] .hh .v.RH + 1 ] .cint = eqtb [ 6746 ] .cint ; 
  427.     } 
  428.     println () ; 
  429.     printnl ( 845 ) ; 
  430.     printscaled ( - (integer) x - totalshrink [ 0 ] ) ; 
  431.     print ( 846 ) ; 
  432.     goto lab50 ; 
  433.       } 
  434.     } 
  435.     else if ( o == 0 ) 
  436.     if ( mem [ r + 5 ] .hh .v.RH != 0 ) 
  437.     {
  438.       lastbadness = badness ( - (integer) x , totalshrink [ 0 ] ) ; 
  439.       if ( lastbadness > eqtb [ 6189 ] .cint ) 
  440.       {
  441.     println () ; 
  442.     printnl ( 847 ) ; 
  443.     printint ( lastbadness ) ; 
  444.     goto lab50 ; 
  445.       } 
  446.     } 
  447.     goto lab10 ; 
  448.   } 
  449.   lab50: if ( outputactive ) 
  450.   print ( 840 ) ; 
  451.   else {
  452.       
  453.     if ( packbeginline != 0 ) 
  454.     {
  455.       if ( packbeginline > 0 ) 
  456.       print ( 841 ) ; 
  457.       else print ( 842 ) ; 
  458.       printint ( abs ( packbeginline ) ) ; 
  459.       print ( 843 ) ; 
  460.     } 
  461.     else print ( 844 ) ; 
  462.     printint ( line ) ; 
  463.   } 
  464.   println () ; 
  465.   fontinshortdisplay = 0 ; 
  466.   shortdisplay ( mem [ r + 5 ] .hh .v.RH ) ; 
  467.   println () ; 
  468.   begindiagnostic () ; 
  469.   showbox ( r ) ; 
  470.   enddiagnostic ( true ) ; 
  471.   lab10: Result = r ; 
  472.   return(Result) ; 
  473. } 
  474. halfword zvpackage ( p , h , m , l ) 
  475. halfword p ; 
  476. scaled h ; 
  477. smallnumber m ; 
  478. scaled l ; 
  479. {/* 50 10 */ register halfword Result; vpackage_regmem 
  480.   halfword r  ; 
  481.   scaled w, d, x  ; 
  482.   scaled s  ; 
  483.   halfword g  ; 
  484.   glueord o  ; 
  485.   lastbadness = 0 ; 
  486.   r = getnode ( 7 ) ; 
  487.   mem [ r ] .hh.b0 = 1 ; 
  488.   mem [ r ] .hh.b1 = 0 ; 
  489.   mem [ r + 4 ] .cint = 0 ; 
  490.   mem [ r + 5 ] .hh .v.RH = p ; 
  491.   w = 0 ; 
  492.   d = 0 ; 
  493.   x = 0 ; 
  494.   totalstretch [ 0 ] = 0 ; 
  495.   totalshrink [ 0 ] = 0 ; 
  496.   totalstretch [ 1 ] = 0 ; 
  497.   totalshrink [ 1 ] = 0 ; 
  498.   totalstretch [ 2 ] = 0 ; 
  499.   totalshrink [ 2 ] = 0 ; 
  500.   totalstretch [ 3 ] = 0 ; 
  501.   totalshrink [ 3 ] = 0 ; 
  502.   while ( p != 0 ) {
  503.       
  504.     if ( ( p >= himemmin ) ) 
  505.     confusion ( 848 ) ; 
  506.     else switch ( mem [ p ] .hh.b0 ) 
  507.     {case 0 : 
  508.     case 1 : 
  509.     case 2 : 
  510.     case 13 : 
  511.       {
  512.     x = x + d + mem [ p + 3 ] .cint ; 
  513.     d = mem [ p + 2 ] .cint ; 
  514.     if ( mem [ p ] .hh.b0 >= 2 ) 
  515.     s = 0 ; 
  516.     else s = mem [ p + 4 ] .cint ; 
  517.     if ( mem [ p + 1 ] .cint + s > w ) 
  518.     w = mem [ p + 1 ] .cint + s ; 
  519.       } 
  520.       break ; 
  521.     case 8 : 
  522.       ; 
  523.       break ; 
  524.     case 10 : 
  525.       {
  526.     x = x + d ; 
  527.     d = 0 ; 
  528.     g = mem [ p + 1 ] .hh .v.LH ; 
  529.     x = x + mem [ g + 1 ] .cint ; 
  530.     o = mem [ g ] .hh.b0 ; 
  531.     totalstretch [ o ] = totalstretch [ o ] + mem [ g + 2 ] .cint ; 
  532.     o = mem [ g ] .hh.b1 ; 
  533.     totalshrink [ o ] = totalshrink [ o ] + mem [ g + 3 ] .cint ; 
  534.     if ( mem [ p ] .hh.b1 >= 100 ) 
  535.     {
  536.       g = mem [ p + 1 ] .hh .v.RH ; 
  537.       if ( mem [ g + 1 ] .cint > w ) 
  538.       w = mem [ g + 1 ] .cint ; 
  539.     } 
  540.       } 
  541.       break ; 
  542.     case 11 : 
  543.       {
  544.     x = x + d + mem [ p + 1 ] .cint ; 
  545.     d = 0 ; 
  546.       } 
  547.       break ; 
  548.       default: 
  549.       ; 
  550.       break ; 
  551.     } 
  552.     p = mem [ p ] .hh .v.RH ; 
  553.   } 
  554.   mem [ r + 1 ] .cint = w ; 
  555.   if ( d > l ) 
  556.   {
  557.     x = x + d - l ; 
  558.     mem [ r + 2 ] .cint = l ; 
  559.   } 
  560.   else mem [ r + 2 ] .cint = d ; 
  561.   if ( m == 1 ) 
  562.   h = x + h ; 
  563.   mem [ r + 3 ] .cint = h ; 
  564.   x = h - x ; 
  565.   if ( x == 0 ) 
  566.   {
  567.     mem [ r + 5 ] .hh.b0 = 0 ; 
  568.     mem [ r + 5 ] .hh.b1 = 0 ; 
  569.     mem [ r + 6 ] .gr = 0.0 ; 
  570.     goto lab10 ; 
  571.   } 
  572.   else if ( x > 0 ) 
  573.   {
  574.     if ( totalstretch [ 3 ] != 0 ) 
  575.     o = 3 ; 
  576.     else if ( totalstretch [ 2 ] != 0 ) 
  577.     o = 2 ; 
  578.     else if ( totalstretch [ 1 ] != 0 ) 
  579.     o = 1 ; 
  580.     else o = 0 ; 
  581.     mem [ r + 5 ] .hh.b1 = o ; 
  582.     mem [ r + 5 ] .hh.b0 = 1 ; 
  583.     if ( totalstretch [ o ] != 0 ) 
  584.     mem [ r + 6 ] .gr = x / ((double) totalstretch [ o ] ) ; 
  585.     else {
  586.     
  587.       mem [ r + 5 ] .hh.b0 = 0 ; 
  588.       mem [ r + 6 ] .gr = 0.0 ; 
  589.     } 
  590.     if ( o == 0 ) 
  591.     if ( mem [ r + 5 ] .hh .v.RH != 0 ) 
  592.     {
  593.       lastbadness = badness ( x , totalstretch [ 0 ] ) ; 
  594.       if ( lastbadness > eqtb [ 6190 ] .cint ) 
  595.       {
  596.     println () ; 
  597.     if ( lastbadness > 100 ) 
  598.     printnl ( 837 ) ; 
  599.     else printnl ( 838 ) ; 
  600.     print ( 849 ) ; 
  601.     printint ( lastbadness ) ; 
  602.     goto lab50 ; 
  603.       } 
  604.     } 
  605.     goto lab10 ; 
  606.   } 
  607.   else {
  608.       
  609.     if ( totalshrink [ 3 ] != 0 ) 
  610.     o = 3 ; 
  611.     else if ( totalshrink [ 2 ] != 0 ) 
  612.     o = 2 ; 
  613.     else if ( totalshrink [ 1 ] != 0 ) 
  614.     o = 1 ; 
  615.     else o = 0 ; 
  616.     mem [ r + 5 ] .hh.b1 = o ; 
  617.     mem [ r + 5 ] .hh.b0 = 2 ; 
  618.     if ( totalshrink [ o ] != 0 ) 
  619.     mem [ r + 6 ] .gr = ( - (integer) x ) / ((double) totalshrink [ o ] ) ; 
  620.     else {
  621.     
  622.       mem [ r + 5 ] .hh.b0 = 0 ; 
  623.       mem [ r + 6 ] .gr = 0.0 ; 
  624.     } 
  625.     if ( ( totalshrink [ o ] < - (integer) x ) && ( o == 0 ) && ( mem [ r + 5 
  626.     ] .hh .v.RH != 0 ) ) 
  627.     {
  628.       lastbadness = 1000000L ; 
  629.       mem [ r + 6 ] .gr = 1.0 ; 
  630.       if ( ( - (integer) x - totalshrink [ 0 ] > eqtb [ 6739 ] .cint ) || ( 
  631.       eqtb [ 6190 ] .cint < 100 ) ) 
  632.       {
  633.     println () ; 
  634.     printnl ( 850 ) ; 
  635.     printscaled ( - (integer) x - totalshrink [ 0 ] ) ; 
  636.     print ( 851 ) ; 
  637.     goto lab50 ; 
  638.       } 
  639.     } 
  640.     else if ( o == 0 ) 
  641.     if ( mem [ r + 5 ] .hh .v.RH != 0 ) 
  642.     {
  643.       lastbadness = badness ( - (integer) x , totalshrink [ 0 ] ) ; 
  644.       if ( lastbadness > eqtb [ 6190 ] .cint ) 
  645.       {
  646.     println () ; 
  647.     printnl ( 852 ) ; 
  648.     printint ( lastbadness ) ; 
  649.     goto lab50 ; 
  650.       } 
  651.     } 
  652.     goto lab10 ; 
  653.   } 
  654.   lab50: if ( outputactive ) 
  655.   print ( 840 ) ; 
  656.   else {
  657.       
  658.     if ( packbeginline != 0 ) 
  659.     {
  660.       print ( 842 ) ; 
  661.       printint ( abs ( packbeginline ) ) ; 
  662.       print ( 843 ) ; 
  663.     } 
  664.     else print ( 844 ) ; 
  665.     printint ( line ) ; 
  666.     println () ; 
  667.   } 
  668.   begindiagnostic () ; 
  669.   showbox ( r ) ; 
  670.   enddiagnostic ( true ) ; 
  671.   lab10: Result = r ; 
  672.   return(Result) ; 
  673. } 
  674. void zappendtovlist ( b ) 
  675. halfword b ; 
  676. {appendtovlist_regmem 
  677.   scaled d  ; 
  678.   halfword p  ; 
  679.   if ( curlist .auxfield .cint > -65536000L ) 
  680.   {
  681.     d = mem [ eqtb [ 3783 ] .hh .v.RH + 1 ] .cint - curlist .auxfield .cint - 
  682.     mem [ b + 3 ] .cint ; 
  683.     if ( d < eqtb [ 6732 ] .cint ) 
  684.     p = newparamglue ( 0 ) ; 
  685.     else {
  686.     
  687.       p = newskipparam ( 1 ) ; 
  688.       mem [ tempptr + 1 ] .cint = d ; 
  689.     } 
  690.     mem [ curlist .tailfield ] .hh .v.RH = p ; 
  691.     curlist .tailfield = p ; 
  692.   } 
  693.   mem [ curlist .tailfield ] .hh .v.RH = b ; 
  694.   curlist .tailfield = b ; 
  695.   curlist .auxfield .cint = mem [ b + 2 ] .cint ; 
  696. } 
  697. halfword newnoad ( ) 
  698. {register halfword Result; newnoad_regmem 
  699.   halfword p  ; 
  700.   p = getnode ( 4 ) ; 
  701.   mem [ p ] .hh.b0 = 16 ; 
  702.   mem [ p ] .hh.b1 = 0 ; 
  703.   mem [ p + 1 ] .hh = emptyfield ; 
  704.   mem [ p + 3 ] .hh = emptyfield ; 
  705.   mem [ p + 2 ] .hh = emptyfield ; 
  706.   Result = p ; 
  707.   return(Result) ; 
  708. } 
  709. halfword znewstyle ( s ) 
  710. smallnumber s ; 
  711. {register halfword Result; newstyle_regmem 
  712.   halfword p  ; 
  713.   p = getnode ( 3 ) ; 
  714.   mem [ p ] .hh.b0 = 14 ; 
  715.   mem [ p ] .hh.b1 = s ; 
  716.   mem [ p + 1 ] .cint = 0 ; 
  717.   mem [ p + 2 ] .cint = 0 ; 
  718.   Result = p ; 
  719.   return(Result) ; 
  720. } 
  721. halfword newchoice ( ) 
  722. {register halfword Result; newchoice_regmem 
  723.   halfword p  ; 
  724.   p = getnode ( 3 ) ; 
  725.   mem [ p ] .hh.b0 = 15 ; 
  726.   mem [ p ] .hh.b1 = 0 ; 
  727.   mem [ p + 1 ] .hh .v.LH = 0 ; 
  728.   mem [ p + 1 ] .hh .v.RH = 0 ; 
  729.   mem [ p + 2 ] .hh .v.LH = 0 ; 
  730.   mem [ p + 2 ] .hh .v.RH = 0 ; 
  731.   Result = p ; 
  732.   return(Result) ; 
  733. } 
  734. void showinfo ( ) 
  735. {showinfo_regmem 
  736.   shownodelist ( mem [ tempptr ] .hh .v.LH ) ; 
  737. } 
  738. halfword zfractionrule ( t ) 
  739. scaled t ; 
  740. {register halfword Result; fractionrule_regmem 
  741.   halfword p  ; 
  742.   p = newrule () ; 
  743.   mem [ p + 3 ] .cint = t ; 
  744.   mem [ p + 2 ] .cint = 0 ; 
  745.   Result = p ; 
  746.   return(Result) ; 
  747. } 
  748. halfword zoverbar ( b , k , t ) 
  749. halfword b ; 
  750. scaled k ; 
  751. scaled t ; 
  752. {register halfword Result; overbar_regmem 
  753.   halfword p, q  ; 
  754.   p = newkern ( k ) ; 
  755.   mem [ p ] .hh .v.RH = b ; 
  756.   q = fractionrule ( t ) ; 
  757.   mem [ q ] .hh .v.RH = p ; 
  758.   p = newkern ( t ) ; 
  759.   mem [ p ] .hh .v.RH = q ; 
  760.   Result = vpackage ( p , 0 , 1 , 1073741823L ) ; 
  761.   return(Result) ; 
  762. } 
  763. halfword zcharbox ( f , c ) 
  764. internalfontnumber f ; 
  765. quarterword c ; 
  766. {register halfword Result; charbox_regmem 
  767.   fourquarters q  ; 
  768.   eightbits hd  ; 
  769.   halfword b, p  ; 
  770.   q = fontinfo [ charbase [ f ] + c ] .qqqq ; 
  771.   hd = q .b1 ; 
  772.   b = newnullbox () ; 
  773.   mem [ b + 1 ] .cint = fontinfo [ widthbase [ f ] + q .b0 ] .cint + fontinfo 
  774.   [ italicbase [ f ] + ( q .b2 ) / 4 ] .cint ; 
  775.   mem [ b + 3 ] .cint = fontinfo [ heightbase [ f ] + ( hd ) / 16 ] .cint ; 
  776.   mem [ b + 2 ] .cint = fontinfo [ depthbase [ f ] + ( hd ) % 16 ] .cint ; 
  777.   p = getavail () ; 
  778.   mem [ p ] .hh.b1 = c ; 
  779.   mem [ p ] .hh.b0 = f ; 
  780.   mem [ b + 5 ] .hh .v.RH = p ; 
  781.   Result = b ; 
  782.   return(Result) ; 
  783. } 
  784. void zstackintobox ( b , f , c ) 
  785. halfword b ; 
  786. internalfontnumber f ; 
  787. quarterword c ; 
  788. {stackintobox_regmem 
  789.   halfword p  ; 
  790.   p = charbox ( f , c ) ; 
  791.   mem [ p ] .hh .v.RH = mem [ b + 5 ] .hh .v.RH ; 
  792.   mem [ b + 5 ] .hh .v.RH = p ; 
  793.   mem [ b + 3 ] .cint = mem [ p + 3 ] .cint ; 
  794. } 
  795. scaled zheightplusdepth ( f , c ) 
  796. internalfontnumber f ; 
  797. quarterword c ; 
  798. {register scaled Result; heightplusdepth_regmem 
  799.   fourquarters q  ; 
  800.   eightbits hd  ; 
  801.   q = fontinfo [ charbase [ f ] + c ] .qqqq ; 
  802.   hd = q .b1 ; 
  803.   Result = fontinfo [ heightbase [ f ] + ( hd ) / 16 ] .cint + fontinfo [ 
  804.   depthbase [ f ] + ( hd ) % 16 ] .cint ; 
  805.   return(Result) ; 
  806. } 
  807. halfword zvardelimiter ( d , s , v ) 
  808. halfword d ; 
  809. smallnumber s ; 
  810. scaled v ; 
  811. {/* 40 22 */ register halfword Result; vardelimiter_regmem 
  812.   halfword b  ; 
  813.   internalfontnumber f, g  ; 
  814.   quarterword c, x, y  ; 
  815.   integer m, n  ; 
  816.   scaled u  ; 
  817.   scaled w  ; 
  818.   fourquarters q  ; 
  819.   eightbits hd  ; 
  820.   fourquarters r  ; 
  821.   smallnumber z  ; 
  822.   boolean largeattempt  ; 
  823.   f = 0 ; 
  824.   w = 0 ; 
  825.   largeattempt = false ; 
  826.   z = mem [ d ] .qqqq .b0 ; 
  827.   x = mem [ d ] .qqqq .b1 ; 
  828.   while ( true ) {
  829.       
  830.     if ( ( z != 0 ) || ( x != 0 ) ) 
  831.     {
  832.       z = z + s + 16 ; 
  833.       do {
  834.       z = z - 16 ; 
  835.     g = eqtb [ 4835 + z ] .hh .v.RH ; 
  836.     if ( g != 0 ) 
  837.     {
  838.       y = x ; 
  839.       if ( ( y >= fontbc [ g ] ) && ( y <= fontec [ g ] ) ) 
  840.       {
  841.         lab22: q = fontinfo [ charbase [ g ] + y ] .qqqq ; 
  842.         if ( ( q .b0 > 0 ) ) 
  843.         {
  844.           if ( ( ( q .b2 ) % 4 ) == 3 ) 
  845.           {
  846.         f = g ; 
  847.         c = y ; 
  848.         goto lab40 ; 
  849.           } 
  850.           hd = q .b1 ; 
  851.           u = fontinfo [ heightbase [ g ] + ( hd ) / 16 ] .cint + fontinfo 
  852.           [ depthbase [ g ] + ( hd ) % 16 ] .cint ; 
  853.           if ( u > w ) 
  854.           {
  855.         f = g ; 
  856.         c = y ; 
  857.         w = u ; 
  858.         if ( u >= v ) 
  859.         goto lab40 ; 
  860.           } 
  861.           if ( ( ( q .b2 ) % 4 ) == 2 ) 
  862.           {
  863.         y = q .b3 ; 
  864.         goto lab22 ; 
  865.           } 
  866.         } 
  867.       } 
  868.     } 
  869.       } while ( ! ( z < 16 ) ) ; 
  870.     } 
  871.     if ( largeattempt ) 
  872.     goto lab40 ; 
  873.     largeattempt = true ; 
  874.     z = mem [ d ] .qqqq .b2 ; 
  875.     x = mem [ d ] .qqqq .b3 ; 
  876.   } 
  877.   lab40: if ( f != 0 ) 
  878.   if ( ( ( q .b2 ) % 4 ) == 3 ) 
  879.   {
  880.     b = newnullbox () ; 
  881.     mem [ b ] .hh.b0 = 1 ; 
  882.     r = fontinfo [ extenbase [ f ] + q .b3 ] .qqqq ; 
  883.     c = r .b3 ; 
  884.     u = heightplusdepth ( f , c ) ; 
  885.     w = 0 ; 
  886.     q = fontinfo [ charbase [ f ] + c ] .qqqq ; 
  887.     mem [ b + 1 ] .cint = fontinfo [ widthbase [ f ] + q .b0 ] .cint + 
  888.     fontinfo [ italicbase [ f ] + ( q .b2 ) / 4 ] .cint ; 
  889.     c = r .b2 ; 
  890.     if ( c != 0 ) 
  891.     w = w + heightplusdepth ( f , c ) ; 
  892.     c = r .b1 ; 
  893.     if ( c != 0 ) 
  894.     w = w + heightplusdepth ( f , c ) ; 
  895.     c = r .b0 ; 
  896.     if ( c != 0 ) 
  897.     w = w + heightplusdepth ( f , c ) ; 
  898.     n = 0 ; 
  899.     if ( u > 0 ) 
  900.     while ( w < v ) {
  901.     
  902.       w = w + u ; 
  903.       incr ( n ) ; 
  904.       if ( r .b1 != 0 ) 
  905.       w = w + u ; 
  906.     } 
  907.     c = r .b2 ; 
  908.     if ( c != 0 ) 
  909.     stackintobox ( b , f , c ) ; 
  910.     c = r .b3 ; 
  911.     {register integer for_end; m = 1 ; for_end = n ; if ( m <= for_end) do 
  912.       stackintobox ( b , f , c ) ; 
  913.     while ( m++ < for_end ) ; } 
  914.     c = r .b1 ; 
  915.     if ( c != 0 ) 
  916.     {
  917.       stackintobox ( b , f , c ) ; 
  918.       c = r .b3 ; 
  919.       {register integer for_end; m = 1 ; for_end = n ; if ( m <= for_end) do 
  920.     stackintobox ( b , f , c ) ; 
  921.       while ( m++ < for_end ) ; } 
  922.     } 
  923.     c = r .b0 ; 
  924.     if ( c != 0 ) 
  925.     stackintobox ( b , f , c ) ; 
  926.     mem [ b + 2 ] .cint = w - mem [ b + 3 ] .cint ; 
  927.   } 
  928.   else b = charbox ( f , c ) ; 
  929.   else {
  930.       
  931.     b = newnullbox () ; 
  932.     mem [ b + 1 ] .cint = eqtb [ 6741 ] .cint ; 
  933.   } 
  934.   mem [ b + 4 ] .cint = half ( mem [ b + 3 ] .cint - mem [ b + 2 ] .cint ) - 
  935.   fontinfo [ 22 + parambase [ eqtb [ 4837 + s ] .hh .v.RH ] ] .cint ; 
  936.   Result = b ; 
  937.   return(Result) ; 
  938. } 
  939. halfword zrebox ( b , w ) 
  940. halfword b ; 
  941. scaled w ; 
  942. {register halfword Result; rebox_regmem 
  943.   halfword p  ; 
  944.   internalfontnumber f  ; 
  945.   scaled v  ; 
  946.   if ( ( mem [ b + 1 ] .cint != w ) && ( mem [ b + 5 ] .hh .v.RH != 0 ) ) 
  947.   {
  948.     if ( mem [ b ] .hh.b0 == 1 ) 
  949.     b = hpack ( b , 0 , 1 ) ; 
  950.     p = mem [ b + 5 ] .hh .v.RH ; 
  951.     if ( ( ( p >= himemmin ) ) && ( mem [ p ] .hh .v.RH == 0 ) ) 
  952.     {
  953.       f = mem [ p ] .hh.b0 ; 
  954.       v = fontinfo [ widthbase [ f ] + fontinfo [ charbase [ f ] + mem [ p ] 
  955.       .hh.b1 ] .qqqq .b0 ] .cint ; 
  956.       if ( v != mem [ b + 1 ] .cint ) 
  957.       mem [ p ] .hh .v.RH = newkern ( mem [ b + 1 ] .cint - v ) ; 
  958.     } 
  959.     freenode ( b , 7 ) ; 
  960.     b = newglue ( 12 ) ; 
  961.     mem [ b ] .hh .v.RH = p ; 
  962.     while ( mem [ p ] .hh .v.RH != 0 ) p = mem [ p ] .hh .v.RH ; 
  963.     mem [ p ] .hh .v.RH = newglue ( 12 ) ; 
  964.     Result = hpack ( b , w , 0 ) ; 
  965.   } 
  966.   else {
  967.       
  968.     mem [ b + 1 ] .cint = w ; 
  969.     Result = b ; 
  970.   } 
  971.   return(Result) ; 
  972. } 
  973. halfword zmathglue ( g , m ) 
  974. halfword g ; 
  975. scaled m ; 
  976. {register halfword Result; mathglue_regmem 
  977.   halfword p  ; 
  978.   integer n  ; 
  979.   scaled f  ; 
  980.   n = xovern ( m , 65536L ) ; 
  981.   f = remainder ; 
  982.   p = getnode ( 4 ) ; 
  983.   mem [ p + 1 ] .cint = multandadd ( n , mem [ g + 1 ] .cint , xnoverd ( mem [ 
  984.   g + 1 ] .cint , f , 65536L ) , 1073741823L ) ; 
  985.   mem [ p ] .hh.b0 = mem [ g ] .hh.b0 ; 
  986.   if ( mem [ p ] .hh.b0 == 0 ) 
  987.   mem [ p + 2 ] .cint = multandadd ( n , mem [ g + 2 ] .cint , xnoverd ( mem [ 
  988.   g + 2 ] .cint , f , 65536L ) , 1073741823L ) ; 
  989.   else mem [ p + 2 ] .cint = mem [ g + 2 ] .cint ; 
  990.   mem [ p ] .hh.b1 = mem [ g ] .hh.b1 ; 
  991.   if ( mem [ p ] .hh.b1 == 0 ) 
  992.   mem [ p + 3 ] .cint = multandadd ( n , mem [ g + 3 ] .cint , xnoverd ( mem [ 
  993.   g + 3 ] .cint , f , 65536L ) , 1073741823L ) ; 
  994.   else mem [ p + 3 ] .cint = mem [ g + 3 ] .cint ; 
  995.   Result = p ; 
  996.   return(Result) ; 
  997. } 
  998. void zmathkern ( p , m ) 
  999. halfword p ; 
  1000. scaled m ; 
  1001. {mathkern_regmem 
  1002.   integer n  ; 
  1003.   scaled f  ; 
  1004.   if ( mem [ p ] .hh.b1 == 99 ) 
  1005.   {
  1006.     n = xovern ( m , 65536L ) ; 
  1007.     f = remainder ; 
  1008.     mem [ p + 1 ] .cint = multandadd ( n , mem [ p + 1 ] .cint , xnoverd ( mem 
  1009.     [ p + 1 ] .cint , f , 65536L ) , 1073741823L ) ; 
  1010.     mem [ p ] .hh.b1 = 0 ; 
  1011.   } 
  1012. } 
  1013.